import { Injectable, Injector } from '@angular/core'
import { Router } from '@angular/router'
import {
  HttpInterceptor,
  HttpRequest,
  HttpHandler,
  HttpErrorResponse,
  HttpEvent,
  HttpResponseBase,
} from '@angular/common/http'
import { Observable, of, throwError } from 'rxjs'
import { mergeMap, catchError } from 'rxjs/operators'
import { NzNotificationService } from 'ng-zorro-antd'
import { _HttpClient } from '@delon/theme'
import { environment } from '@env/environment'
import { DA_SERVICE_TOKEN, ITokenService, JWTTokenModel } from '@delon/auth'
import { I18NService } from '@core/i18n/i18n.service'
import { errorWhiteUrl } from 'app/utils/contraints'

const CODEMESSAGE = {
  200: '服务器成功返回请求的数据。',
  201: '新建或修改数据成功。',
  202: '一个请求已经进入后台排队（异步任务）。',
  204: '删除数据成功。',
  400: '发出的请求有错误，服务器没有进行新建或修改数据的操作。',
  401: '用户没有权限（令牌、用户名、密码错误）。',
  403: '用户得到授权，但是访问是被禁止的。',
  404: '发出的请求针对的是不存在的记录，服务器没有进行操作。',
  406: '请求的格式不可得。',
  410: '请求的资源被永久删除，且不会再得到的。',
  422: '当创建一个对象时，发生一个验证错误。',
  423: '数据被锁住',
  500: '服务器发生错误，请检查服务器。',
  502: '网关错误。',
  503: '服务不可用，服务器暂时过载或维护。',
  504: '网关超时。',
}

/**
 * 默认HTTP拦截器，其注册细节见 `app.module.ts`
 */
@Injectable()
export class DefaultInterceptor implements HttpInterceptor {
  constructor(private injector: Injector) {}

  private get notification(): NzNotificationService {
    return this.injector.get(NzNotificationService)
  }

  private get i18n(): I18NService {
    return this.injector.get(I18NService)
  }

  private goTo(url: string) {
    setTimeout(() => this.injector.get(Router).navigateByUrl(url))
  }

  private checkStatus(ev: HttpResponseBase) {
    if ((ev.status >= 200 && ev.status < 300) || ev.status === 401 || ev.status === 409) {
      return
    }

    const errortext = CODEMESSAGE[ev.status] || ev.statusText
    this.notification.error(`请求错误 ${ev.status}: ${ev.url}`, errortext)
  }

  private handleData(ev: HttpErrorResponse): Observable<any> {
    // 可能会因为 `throw` 导出无法执行 `_HttpClient` 的 `end()` 操作
    if (ev.status > 0) {
      this.injector.get(_HttpClient).end()
    }

    let msg = ev.error ? ev.error.msg : ''
    if (!msg) {
      msg = ev.error
    }

    // this.checkStatus(ev)
    // 业务处理：一些通用操作
    switch (ev.status) {
      case 200:
        // 业务层级错误处理，以下是假定restful有一套统一输出格式（指不管成功与否都有相应的数据格式）情况下进行处理
        // 例如响应内容：
        //  错误内容：{ status: 1, msg: '非法参数' }
        //  正确内容：{ status: 0, response: {  } }
        // 则以下代码片断可直接适用
        // if (event instanceof HttpResponse) {
        //     const body: any = event.body;
        //     if (body && body.status !== 0) {
        //         this.msg.error(body.msg);
        //         // 继续抛出错误中断后续所有 Pipe、subscribe 操作，因此：
        //         // this.http.get('/').subscribe() 并不会触发
        //         return throwError({});
        //     } else {
        //         // 重新修改 `body` 内容为 `response` 内容，对于绝大多数场景已经无须再关心业务状态码
        //         return of(new HttpResponse(Object.assign(event, { body: body.response })));
        //         // 或者依然保持完整的格式
        //         return of(event);
        //     }
        // }
        console.log('ev', ev)
        break
      case 201:
        // 一般表示创建成功
        break
      case 202:
        // 一般表示需要一些异步的操作， 比如提交审核
        break
      case 400:
        if (ev.url.includes('/auth/login')) {
          /* 先 mock 处理，后续后端要返回对应的错误msg */
          this.notification.error(`${msg}`, ``)
          return of(ev)
        }
        if (errorWhiteUrl.some(item => ev.url.includes(item))) {
          return of(ev)
        }
        this.notification.error(this.trans('GENERAL.NOTIFICATION.BAD_REQUEST'), `${msg}`)
        break
      case 401:
        const service = this.injector.get(DA_SERVICE_TOKEN) as ITokenService
        const model = service.get<JWTTokenModel>(JWTTokenModel)
        if (model.token) {
          this.notification.error(this.trans('GENERAL.NOTIFICATION.UNAUTHORIZED'), this.trans('GENERAL.NOTIFICATION.SESSION_OUTDATE'))
          // 清空 token 信息
          service.clear()
        }
        this.goTo('/passport/login')
        break
      case 403:
        this.notification.error(this.trans('GENERAL.NOTIFICATION.FORBIDDEN'), `${msg}`)
        break
      case 404:
        break
      case 406:
        this.notification.error(this.trans('GENERAL.NOTIFICATION.NO_ACCEPTABLE'), `${CODEMESSAGE['406']}`)
        break
      case 409:
        break
      case 423:
        this.notification.error(this.trans('GENERAL.NOTIFICATION.LOCKED'), `${msg}`)
        break
      case 426:
        // 数据版本需要更新。业务数据中会有一个Version字段，在更新接口中，会比较这个Version字段，如果不一致那么表示数据已经被更新过了，需要前端重新拉取最新的数据
        break
      case 500:
        this.goTo(`/exception/${ev.status}`)
        break
      default:
        if (ev instanceof HttpErrorResponse) {
          console.warn('未可知错误，大部分是由于后端不支持CORS或无效配置引起', ev)
          return throwError(ev)
        }
        break
    }
    return of(ev)
  }

  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
    // 统一加上服务端前缀
    let url = req.url
    if (!url.startsWith('https://') && !url.startsWith('http://') && !url.startsWith('/')) {
      url = environment.SERVER_URL + url
    }

    const newReq = req.clone({
      url,
      setHeaders: {
        'X-Accept-Language': this.i18n.XAcceptLanguage,
      },
    })

    return next.handle(newReq).pipe(
      mergeMap((event: any) => {
        // 允许统一对请求错误处理
        if (event instanceof HttpErrorResponse) return this.handleData(event)
        // 若一切都正常，则后续操作
        return of(event)
      }),
      catchError((err: HttpErrorResponse) => {
        this.handleData(err)
        return throwError(err)
      }),
    )
  }

  trans(key: string, params?: Object): string {
    return this.i18n.fanyi(key, params)
  }
}
